package com.ruoyi.movie.service.impl;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

import com.ruoyi.basic.domain.Column;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.movie.mapper.MovieBasicsMapper;
import com.ruoyi.movie.domain.MovieBasics;
import com.ruoyi.movie.service.IMovieBasicsService;

/**
 * 影视基础信息Service业务层处理
 *
 * @author ruoyi
 * @date 2025-10-27
 */
@Service
public class MovieBasicsServiceImpl implements IMovieBasicsService
{
    @Autowired
    private MovieBasicsMapper movieBasicsMapper;

    @Autowired
    private RedisCache redisCache;
    // 缓存key前缀
    private static final String YEAR_LIST_KEY = "year:list:";
    // 缓存key前缀
    private static final String COUNTRY_LIST_KEY = "country:list:";

    private static final Integer CACHE_TTL = 86400;
    /**
     * 查询影视基础信息
     *
     * @param movieBasicsId 影视基础信息主键
     * @return 影视基础信息
     */
    @Override
    public MovieBasics selectMovieBasicsById(Integer movieBasicsId)
    {
        return movieBasicsMapper.selectMovieBasicsById(movieBasicsId);
    }

    /**
     * 查询影视基础信息列表
     *
     * @param movieBasics 影视基础信息
     * @return 影视基础信息
     */
    @Override
    public List<MovieBasics> selectMovieBasicsList(MovieBasics movieBasics)
    {
        return movieBasicsMapper.selectMovieBasicsList(movieBasics);
    }

    /**
     * 新增影视基础信息
     *
     * @param movieBasics 影视基础信息
     * @return 结果
     */
    @Override
    public int insertMovieBasics(MovieBasics movieBasics)
    {
        movieBasics.setCreateTime(DateUtils.getNowDate());
        return movieBasicsMapper.insertMovieBasics(movieBasics);
    }

    /**
     * 修改影视基础信息
     *
     * @param movieBasics 影视基础信息
     * @return 结果
     */
    @Override
    public int updateMovieBasics(MovieBasics movieBasics)
    {
        movieBasics.setUpdateTime(DateUtils.getNowDate());
        return movieBasicsMapper.updateMovieBasics(movieBasics);
    }

    /**
     * 批量删除影视基础信息
     *
     * @param movieBasicsIds 需要删除的影视基础信息主键
     * @return 结果
     */
    @Override
    public int deleteMovieBasicsByIds(Integer[] movieBasicsIds)
    {
        return movieBasicsMapper.deleteMovieBasicsByIds(movieBasicsIds);
    }

    /**
     * 删除影视基础信息
     *
     * @param movieBasicsId 影视基础信息主键
     * @return 结果
     */
    @Override
    public int deleteMovieBasicsById(Integer movieBasicsId)
    {
        return movieBasicsMapper.deleteMovieBasicsById(movieBasicsId);
    }

    /**
     * 根据采集ID查询影视
     *
     * @param collectFrom 采集来源
     * @param collectId 采集ID
     * @return 影视基础信息
     */
    @Override
    public MovieBasics selectMovieByCollectId(String collectFrom, String collectId)
    {
        return movieBasicsMapper.selectMovieByCollectId(collectFrom, collectId);
    }

    /**
     * 批量查询影视（根据采集ID列表）
     *
     * @param collectIds 采集ID列表
     * @return 影视基础信息集合
     */
    @Override
    public List<MovieBasics> selectMoviesByCollectIds(List<String> collectIds, String siteFlag)
    {
        if (collectIds == null || collectIds.isEmpty()) {
            return new ArrayList<>();
        }
        return movieBasicsMapper.selectMoviesByCollectIds(collectIds,siteFlag);
    }

    /**
     * 查询影视基础信息列表（去重版本，按title+year去重）
     *
     * @param movieBasics 影视基础信息
     * @return 影视基础信息集合（去重后）
     */
    @Override
    public List<MovieBasics> selectMovieBasicsListDistinct(MovieBasics movieBasics)
    {
        return movieBasicsMapper.selectMovieBasicsListDistinct(movieBasics);
    }

    /**
     * 获取首页推荐影视（去重版本，限制数量，按pub_date排序）
     *
     * @param columnValue 栏目值
     * @param limit 数量限制
     * @return 影视基础信息集合
     */
    @Override
    public List<MovieBasics> selectHomeRecommendMovies(String columnValue, int limit)
    {
        return movieBasicsMapper.selectHomeRecommendMovies(columnValue, limit);
    }

    @Override
    public List<Integer> selectDistinctYears(String columnValue) {
        if(StringUtils.isEmpty(columnValue)){
            return new ArrayList<>();
        }
        // 构建缓存key
        String cacheKey = YEAR_LIST_KEY+columnValue ;

        // 尝试从缓存获取
        List<Integer> columnData = redisCache.getCacheObject(cacheKey);
        if (columnData != null) {
            return columnData;
        }
        List<Integer>newList = movieBasicsMapper.selectDistinctYears(columnValue);
        if (newList != null && newList.size() > 0) {
            // 存入缓存
            redisCache.setCacheObject(cacheKey, newList, CACHE_TTL, TimeUnit.SECONDS);
        }else{
            return new ArrayList<>();
        }
        return newList;
    }

    @Override
    public List<String> selectDistinctAreas(String columnValue) {
        if(StringUtils.isEmpty(columnValue)){
            return new ArrayList<>();
        }
        // 构建缓存key
        String cacheKey = COUNTRY_LIST_KEY+columnValue;
        // 尝试从缓存获取
        List<String> columnData = redisCache.getCacheObject(cacheKey);
        if (columnData != null) {
            return columnData;
        }
        List<String>newList = movieBasicsMapper.selectDistinctAreas(columnValue);
        if (newList != null && newList.size() > 0) {
            // 存入缓存
            redisCache.setCacheObject(cacheKey, newList, CACHE_TTL, TimeUnit.SECONDS);
        }else{
            return new ArrayList<>();
        }
        return newList;
    }
}
